home *** CD-ROM | disk | FTP | other *** search
/ Champak 143 / (Vol 143) Nov 15 2011.iso / Games / xeno_tactic.swf / scripts / DefineSprite_88 / frame_5 / DoAction.as
Text File  |  2011-11-15  |  55KB  |  1,159 lines
  1. var ┬º\x01┬º = 505;
  2. loop0:
  3. while(eval("\x01") != 505)
  4. {
  5.    if(eval("\x01") == 534)
  6.    {
  7.       break;
  8.    }
  9.    if(eval("\x01") == 754)
  10.    {
  11.       break;
  12.    }
  13.    if(eval("\x01") == 352)
  14.    {
  15.       break;
  16.    }
  17.    if(eval("\x01") == 972)
  18.    {
  19.       break;
  20.    }
  21.    if(eval("\x01") == 158)
  22.    {
  23.       break;
  24.    }
  25.    if(eval("\x01") == 200)
  26.    {
  27.       break;
  28.    }
  29.    if(eval("\x01") == 577)
  30.    {
  31.       break;
  32.    }
  33.    if(eval("\x01") == 33)
  34.    {
  35.       break;
  36.    }
  37.    if(eval("\x01") == 193)
  38.    {
  39.       break;
  40.    }
  41.    if(eval("\x01") == 658)
  42.    {
  43.       break;
  44.    }
  45.    if(eval("\x01") == 367)
  46.    {
  47.       break;
  48.    }
  49.    if(eval("\x01") == 750)
  50.    {
  51.       break;
  52.    }
  53.    if(eval("\x01") == 776)
  54.    {
  55.       break;
  56.    }
  57.    if(eval("\x01") == 829)
  58.    {
  59.       break;
  60.    }
  61.    if(eval("\x01") == 742)
  62.    {
  63.       break;
  64.    }
  65.    if(eval("\x01") == 755)
  66.    {
  67.       break;
  68.    }
  69.    if(eval("\x01") == 973)
  70.    {
  71.       break;
  72.    }
  73.    if(eval("\x01") == 814)
  74.    {
  75.       break;
  76.    }
  77.    if(eval("\x01") == 170)
  78.    {
  79.       break;
  80.    }
  81.    if(eval("\x01") == 407)
  82.    {
  83.       break;
  84.    }
  85.    if(eval("\x01") == 558)
  86.    {
  87.       break;
  88.    }
  89.    if(eval("\x01") == 714)
  90.    {
  91.       break;
  92.    }
  93.    if(eval("\x01") == 451)
  94.    {
  95.       break;
  96.    }
  97.    if(eval("\x01") == 827)
  98.    {
  99.       break;
  100.    }
  101.    if(eval("\x01") == 21)
  102.    {
  103.       break;
  104.    }
  105.    if(eval("\x01") == 100)
  106.    {
  107.       addr3820:
  108.       break;
  109.    }
  110.    if(eval("\x01") == 423)
  111.    {
  112.       set("\x01",eval("\x01") + 232);
  113.       set(┬º┬ºpop(),┬º┬ºpop() - 91);
  114.       if(┬º┬ºpop())
  115.       {
  116.          set("\x01",eval("\x01") + 334);
  117.          while(eval("\x01") != 331)
  118.          {
  119.             if(eval("\x01") != 120)
  120.             {
  121.                if(eval("\x01") != 184)
  122.                {
  123.                   if(eval("\x01") != 169)
  124.                   {
  125.                      if(eval("\x01") != 744)
  126.                      {
  127.                         if(eval("\x01") != 963)
  128.                         {
  129.                            if(eval("\x01") != 211)
  130.                            {
  131.                               if(eval("\x01") != 775)
  132.                               {
  133.                                  if(eval("\x01") != 544)
  134.                                  {
  135.                                     if(eval("\x01") != 934)
  136.                                     {
  137.                                        if(eval("\x01") != 377)
  138.                                        {
  139.                                           if(eval("\x01") == 932)
  140.                                           {
  141.                                              set("\x01",eval("\x01") - 555);
  142.                                              break loop0;
  143.                                           }
  144.                                           if(eval("\x01") == 689)
  145.                                           {
  146.                                              set("\x01",eval("\x01") + 86);
  147.                                           }
  148.                                           else if(eval("\x01") == 4)
  149.                                           {
  150.                                              set("\x01",eval("\x01") + 929);
  151.                                              loop2:
  152.                                              while(true)
  153.                                              {
  154.                                                 set(┬º┬ºpop(),eval("\x01") + 917);
  155.                                                 ┬º┬ºpush(true);
  156.                                                 while(true)
  157.                                                 {
  158.                                                    if(eval("\x01") != 361)
  159.                                                    {
  160.                                                       if(eval("\x01") != 927)
  161.                                                       {
  162.                                                          if(eval("\x01") == 464)
  163.                                                          {
  164.                                                             set("\x01",eval("\x01") - 16);
  165.                                                             break;
  166.                                                          }
  167.                                                          if(eval("\x01") == 275)
  168.                                                          {
  169.                                                             set("\x01",eval("\x01") + 122);
  170.                                                             ┬º┬ºpush(true);
  171.                                                             continue;
  172.                                                             continue;
  173.                                                          }
  174.                                                          if(eval("\x01") == 397)
  175.                                                          {
  176.                                                             set("\x01",eval("\x01") + 57);
  177.                                                             if(┬º┬ºpop())
  178.                                                             {
  179.                                                                set("\x01",eval("\x01") - 337);
  180.                                                             }
  181.                                                             continue;
  182.                                                          }
  183.                                                          if(eval("\x01") == 203)
  184.                                                          {
  185.                                                             set("\x01",eval("\x01") + 582);
  186.                                                             ┬º┬ºpush(true);
  187.                                                             continue;
  188.                                                          }
  189.                                                          if(eval("\x01") == 446)
  190.                                                          {
  191.                                                             set("\x01",eval("\x01") + 30);
  192.                                                             if(┬º┬ºpop())
  193.                                                             {
  194.                                                                set("\x01",eval("\x01") - 273);
  195.                                                             }
  196.                                                             continue;
  197.                                                          }
  198.                                                          if(eval("\x01") != 3)
  199.                                                          {
  200.                                                             if(eval("\x01") != 879)
  201.                                                             {
  202.                                                                if(eval("\x01") == 246)
  203.                                                                {
  204.                                                                   set("\x01",eval("\x01") + 29);
  205.                                                                   break;
  206.                                                                }
  207.                                                                if(eval("\x01") == 412)
  208.                                                                {
  209.                                                                   set("\x01",eval("\x01") + 453);
  210.                                                                   break;
  211.                                                                }
  212.                                                                if(eval("\x01") == 476)
  213.                                                                {
  214.                                                                   set("\x01",eval("\x01") - 273);
  215.                                                                   break;
  216.                                                                }
  217.                                                                if(eval("\x01") == 947)
  218.                                                                {
  219.                                                                   set("\x01",eval("\x01") - 535);
  220.                                                                   if(┬º┬ºpop())
  221.                                                                   {
  222.                                                                      set("\x01",eval("\x01") + 453);
  223.                                                                   }
  224.                                                                   continue;
  225.                                                                }
  226.                                                                if(eval("\x01") != 538)
  227.                                                                {
  228.                                                                   if(eval("\x01") != 10)
  229.                                                                   {
  230.                                                                      if(eval("\x01") == 454)
  231.                                                                      {
  232.                                                                         set("\x01",eval("\x01") - 337);
  233.                                                                         stopAllSounds();
  234.                                                                         ┬º┬ºpush(┬º┬ºpop() < (┬º┬ºpop() < ┬º┬ºpop() - (┬º┬ºpop() - (┬º┬ºpop() - (┬º┬ºpop() - 1 - 1)))));
  235.                                                                         break;
  236.                                                                      }
  237.                                                                      if(eval("\x01") == 117)
  238.                                                                      {
  239.                                                                         set("\x01",eval("\x01") + 170);
  240.                                                                         ┬º┬ºpush(true);
  241.                                                                         continue;
  242.                                                                         continue;
  243.                                                                      }
  244.                                                                      if(eval("\x01") != 957)
  245.                                                                      {
  246.                                                                         if(eval("\x01") != 287)
  247.                                                                         {
  248.                                                                            if(eval("\x01") == 956)
  249.                                                                            {
  250.                                                                               set("\x01",eval("\x01") - 953);
  251.                                                                               break;
  252.                                                                            }
  253.                                                                            if(eval("\x01") == 785)
  254.                                                                            {
  255.                                                                               set("\x01",eval("\x01") + 171);
  256.                                                                               if(┬º┬ºpop())
  257.                                                                               {
  258.                                                                                  set("\x01",eval("\x01") - 953);
  259.                                                                               }
  260.                                                                               continue;
  261.                                                                            }
  262.                                                                            if(eval("\x01") == 865)
  263.                                                                            {
  264.                                                                               set("\x01",eval("\x01") - 419);
  265.                                                                               ┬º┬ºpush(true);
  266.                                                                               continue;
  267.                                                                            }
  268.                                                                            if(eval("\x01") != 448)
  269.                                                                            {
  270.                                                                               if(eval("\x01") == 950)
  271.                                                                               {
  272.                                                                                  set("\x01",eval("\x01") - 71);
  273.                                                                                  ┬º┬ºenumerate(┬º┬ºpop());
  274.                                                                                  removeMovieClip(┬º┬ºenumeration());
  275.                                                                                  break;
  276.                                                                               }
  277.                                                                               if(eval("\x01") == 345)
  278.                                                                               {
  279.                                                                                  set("\x01",eval("\x01") - 335);
  280.                                                                                  break;
  281.                                                                               }
  282.                                                                               if(eval("\x01") == 64)
  283.                                                                               {
  284.                                                                                  set("\x01",eval("\x01") + 72);
  285.                                                                                  var ┬ºaso#16344┬º;
  286.                                                                                  break;
  287.                                                                               }
  288.                                                                            }
  289.                                                                            set("\x01",eval("\x01") + 90);
  290.                                                                         }
  291.                                                                         set("\x01",eval("\x01") + 177);
  292.                                                                         if(┬º┬ºpop())
  293.                                                                         {
  294.                                                                            set("\x01",eval("\x01") - 16);
  295.                                                                         }
  296.                                                                         continue;
  297.                                                                         ┬º┬ºpush(true);
  298.                                                                      }
  299.                                                                      set("\x01",eval("\x01") - 711);
  300.                                                                      if(┬º┬ºpop())
  301.                                                                      {
  302.                                                                         set("\x01",eval("\x01") + 29);
  303.                                                                      }
  304.                                                                   }
  305.                                                                   continue loop2;
  306.                                                                   continue;
  307.                                                                }
  308.                                                                set("\x01",eval("\x01") - 193);
  309.                                                             }
  310.                                                             set("\x01",eval("\x01") - 815);
  311.                                                             continue;
  312.                                                             if(┬º┬ºpop())
  313.                                                             {
  314.                                                                set("\x01",eval("\x01") - 335);
  315.                                                             }
  316.                                                          }
  317.                                                       }
  318.                                                       set("\x01",eval("\x01") + 23);
  319.                                                       if(┬º┬ºpop())
  320.                                                       {
  321.                                                          set("\x01",eval("\x01") - 71);
  322.                                                       }
  323.                                                       continue;
  324.                                                       set("\x01",eval("\x01") + 954);
  325.                                                    }
  326.                                                    set("\x01",eval("\x01") + 586);
  327.                                                    ┬º┬ºpush(true);
  328.                                                    continue;
  329.                                                    ┬º┬ºpush(true);
  330.                                                    continue;
  331.                                                    if(eval("\x01") == 136)
  332.                                                    {
  333.                                                       set("\x01",eval("\x01") - 136);
  334.                                                       break;
  335.                                                    }
  336.                                                    break;
  337.                                                 }
  338.                                              }
  339.                                           }
  340.                                           else if(eval("\x01") == 212)
  341.                                           {
  342.                                              set("\x01",eval("\x01") - 212);
  343.                                           }
  344.                                           else
  345.                                           {
  346.                                              if(eval("\x01") == 431)
  347.                                              {
  348.                                                 set("\x01",eval("\x01") - 404);
  349.                                                 if(┬º┬ºpop())
  350.                                                 {
  351.                                                    set("\x01",eval("\x01") + 747);
  352.                                                 }
  353.                                                 continue;
  354.                                              }
  355.                                              if(eval("\x01") == 617)
  356.                                              {
  357.                                                 set("\x01",eval("\x01") + 315);
  358.                                                 if(┬º┬ºpop())
  359.                                                 {
  360.                                                    set("\x01",eval("\x01") - 555);
  361.                                                 }
  362.                                                 continue;
  363.                                              }
  364.                                              if(eval("\x01") == 454)
  365.                                              {
  366.                                                 set("\x01",eval("\x01") + 163);
  367.                                                 ┬º┬ºpush(true);
  368.                                                 continue;
  369.                                              }
  370.                                              if(eval("\x01") == 774)
  371.                                              {
  372.                                                 set("\x01",eval("\x01") + 160);
  373.                                                 ┬º┬ºpush(true);
  374.                                                 continue;
  375.                                              }
  376.                                              if(eval("\x01") == 829)
  377.                                              {
  378.                                                 set("\x01",eval("\x01") - 140);
  379.                                                 if(┬º┬ºpop())
  380.                                                 {
  381.                                                    set("\x01",eval("\x01") + 86);
  382.                                                 }
  383.                                                 continue;
  384.                                              }
  385.                                              if(eval("\x01") == 72)
  386.                                              {
  387.                                                 set("\x01",eval("\x01") + 672);
  388.                                                 if(┬º┬ºpop())
  389.                                                 {
  390.                                                    set("\x01",eval("\x01") - 271);
  391.                                                 }
  392.                                                 continue;
  393.                                              }
  394.                                              if(eval("\x01") == 27)
  395.                                              {
  396.                                                 set("\x01",eval("\x01") + 747);
  397.                                              }
  398.                                              else
  399.                                              {
  400.                                                 if(eval("\x01") == 105)
  401.                                                 {
  402.                                                    set("\x01",eval("\x01") + 724);
  403.                                                    ┬º┬ºpush(true);
  404.                                                    continue;
  405.                                                 }
  406.                                                 if(eval("\x01") == 933)
  407.                                                 {
  408.                                                    set("\x01",eval("\x01") - 502);
  409.                                                    ┬º┬ºpush(true);
  410.                                                    continue;
  411.                                                 }
  412.                                                 if(eval("\x01") == 289)
  413.                                                 {
  414.                                                    set("\x01",eval("\x01") - 285);
  415.                                                    if(┬º┬ºpop())
  416.                                                    {
  417.                                                       set("\x01",eval("\x01") + 929);
  418.                                                    }
  419.                                                    continue;
  420.                                                 }
  421.                                                 if(eval("\x01") == 473)
  422.                                                 {
  423.                                                    set("\x01",eval("\x01") - 184);
  424.                                                    ┬º┬ºpush(true);
  425.                                                    continue;
  426.                                                 }
  427.                                              }
  428.                                           }
  429.                                        }
  430.                                        break loop0;
  431.                                     }
  432.                                     break loop0;
  433.                                  }
  434.                                  break loop0;
  435.                               }
  436.                               break loop0;
  437.                            }
  438.                            break loop0;
  439.                         }
  440.                         break loop0;
  441.                      }
  442.                      break loop0;
  443.                   }
  444.                   break loop0;
  445.                }
  446.                break loop0;
  447.             }
  448.             break loop0;
  449.          }
  450.          break;
  451.       }
  452.       break;
  453.    }
  454.    if(eval("\x01") != 655)
  455.    {
  456.    }
  457.    set("\x01",eval("\x01") - 288);
  458. }
  459. try
  460. {
  461.    set(┬º┬ºpop(),┬º┬ºpop());
  462.    if(!┬º┬ºpop())
  463.    {
  464.       loop3:
  465.       while(true)
  466.       {
  467.          set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  468.          ┬º┬ºpush(true);
  469.          while(true)
  470.          {
  471.             if(eval("\x01") == 657)
  472.             {
  473.                set("\x01",eval("\x01") - 392);
  474.                ┬º┬ºpush(true);
  475.                continue;
  476.             }
  477.             if(eval("\x01") == 374)
  478.             {
  479.                set("\x01",eval("\x01") + 39);
  480.                ┬º┬ºpush(true);
  481.                continue;
  482.             }
  483.             if(eval("\x01") == 613)
  484.             {
  485.                set("\x01",eval("\x01") + 146);
  486.             }
  487.             else
  488.             {
  489.                if(eval("\x01") == 835)
  490.                {
  491.                   set("\x01",eval("\x01") - 611);
  492.                   if(┬º┬ºpop())
  493.                   {
  494.                      set("\x01",eval("\x01") + 150);
  495.                   }
  496.                   continue;
  497.                }
  498.                if(eval("\x01") == 616)
  499.                {
  500.                   set("\x01",eval("\x01") - 437);
  501.                }
  502.                if(eval("\x01") == 759)
  503.                {
  504.                   set("\x01",eval("\x01") + 6);
  505.                   ┬º┬ºpush(true);
  506.                   continue;
  507.                }
  508.                if(eval("\x01") == 510)
  509.                {
  510.                   set("\x01",eval("\x01") - 359);
  511.                }
  512.                else
  513.                {
  514.                   if(eval("\x01") == 115)
  515.                   {
  516.                      set("\x01",eval("\x01") + 501);
  517.                      if(┬º┬ºpop())
  518.                      {
  519.                         set("\x01",eval("\x01") - 437);
  520.                      }
  521.                      continue;
  522.                   }
  523.                   if(eval("\x01") == 222)
  524.                   {
  525.                      set("\x01",eval("\x01") + 261);
  526.                   }
  527.                   if(eval("\x01") == 734)
  528.                   {
  529.                      set("\x01",eval("\x01") - 534);
  530.                      ┬º┬ºpush(true);
  531.                      continue;
  532.                   }
  533.                   if(eval("\x01") == 854)
  534.                   {
  535.                      set("\x01",eval("\x01") - 19);
  536.                      ┬º┬ºpush(true);
  537.                      continue;
  538.                   }
  539.                   if(eval("\x01") == 604)
  540.                   {
  541.                      set("\x01",eval("\x01") - 99);
  542.                      if(┬º┬ºpop())
  543.                      {
  544.                         set("\x01",eval("\x01") + 349);
  545.                      }
  546.                      continue;
  547.                   }
  548.                   if(eval("\x01") == 350)
  549.                   {
  550.                      set("\x01",eval("\x01") + 263);
  551.                      if(┬º┬ºpop())
  552.                      {
  553.                         set("\x01",eval("\x01") + 146);
  554.                      }
  555.                      continue;
  556.                   }
  557.                   if(eval("\x01") == 483)
  558.                   {
  559.                      set("\x01",eval("\x01") + 345);
  560.                      ┬º┬ºpush(true);
  561.                      continue;
  562.                   }
  563.                   if(eval("\x01") == 224)
  564.                   {
  565.                      set("\x01",eval("\x01") + 150);
  566.                   }
  567.                   else
  568.                   {
  569.                      if(eval("\x01") == 413)
  570.                      {
  571.                         set("\x01",eval("\x01") + 97);
  572.                         if(┬º┬ºpop())
  573.                         {
  574.                            set("\x01",eval("\x01") - 359);
  575.                         }
  576.                         continue;
  577.                      }
  578.                      if(eval("\x01") == 179)
  579.                      {
  580.                         set("\x01",eval("\x01") + 425);
  581.                         ┬º┬ºpush(true);
  582.                         continue;
  583.                      }
  584.                      if(eval("\x01") == 375)
  585.                      {
  586.                         set("\x01",eval("\x01") - 34);
  587.                         ┬º┬ºpush(true);
  588.                         continue;
  589.                      }
  590.                      if(eval("\x01") == 112)
  591.                      {
  592.                         break loop3;
  593.                      }
  594.                      if(eval("\x01") == 739)
  595.                      {
  596.                         break;
  597.                      }
  598.                      if(eval("\x01") == 389)
  599.                      {
  600.                         set("\x01",eval("\x01") + 350);
  601.                         loop5:
  602.                         while(true)
  603.                         {
  604.                            set(┬º┬ºpop(),eval("\x01") + 587);
  605.                            ┬º┬ºpush(true);
  606.                            while(eval("\x01") != 36)
  607.                            {
  608.                               if(eval("\x01") == 648)
  609.                               {
  610.                                  set("\x01",eval("\x01") - 109);
  611.                                  ┬º┬ºpush(true);
  612.                                  continue;
  613.                               }
  614.                               if(eval("\x01") == 906)
  615.                               {
  616.                                  set("\x01",eval("\x01") - 888);
  617.                               }
  618.                               else
  619.                               {
  620.                                  if(eval("\x01") == 623)
  621.                                  {
  622.                                     set("\x01",eval("\x01") + 283);
  623.                                     if(┬º┬ºpop())
  624.                                     {
  625.                                        set("\x01",eval("\x01") - 888);
  626.                                     }
  627.                                     continue;
  628.                                  }
  629.                                  if(eval("\x01") == 539)
  630.                                  {
  631.                                     set("\x01",eval("\x01") + 164);
  632.                                     if(┬º┬ºpop())
  633.                                     {
  634.                                        set("\x01",eval("\x01") + 103);
  635.                                     }
  636.                                     continue;
  637.                                  }
  638.                                  if(eval("\x01") == 722)
  639.                                  {
  640.                                     set("\x01",eval("\x01") - 345);
  641.                                     if(┬º┬ºpop())
  642.                                     {
  643.                                        set("\x01",eval("\x01") + 340);
  644.                                     }
  645.                                     continue;
  646.                                  }
  647.                                  if(eval("\x01") == 703)
  648.                                  {
  649.                                     break loop5;
  650.                                  }
  651.                                  if(eval("\x01") == 840)
  652.                                  {
  653.                                     set("\x01",eval("\x01") - 486);
  654.                                     ┬º┬ºpush(true);
  655.                                     continue;
  656.                                  }
  657.                                  if(eval("\x01") == 796)
  658.                                  {
  659.                                     set("\x01",eval("\x01") - 254);
  660.                                  }
  661.                                  if(eval("\x01") == 18)
  662.                                  {
  663.                                     set("\x01",eval("\x01") + 83);
  664.                                     ┬º┬ºpush(true);
  665.                                     continue;
  666.                                  }
  667.                                  if(eval("\x01") == 806)
  668.                                  {
  669.                                     set("\x01",eval("\x01") - 84);
  670.                                     ┬º┬ºpush(true);
  671.                                     continue;
  672.                                  }
  673.                                  if(eval("\x01") == 581)
  674.                                  {
  675.                                     set("\x01",eval("\x01") + 259);
  676.                                  }
  677.                                  else if(eval("\x01") == 377)
  678.                                  {
  679.                                     set("\x01",eval("\x01") + 340);
  680.                                     ┬º┬ºpush(┬º┬ºpop() - ┬º┬ºpop());
  681.                                  }
  682.                                  else
  683.                                  {
  684.                                     if(eval("\x01") == 354)
  685.                                     {
  686.                                        set("\x01",eval("\x01") + 442);
  687.                                        if(┬º┬ºpop())
  688.                                        {
  689.                                           set("\x01",eval("\x01") - 254);
  690.                                        }
  691.                                        continue;
  692.                                     }
  693.                                     if(eval("\x01") == 624)
  694.                                     {
  695.                                        set("\x01",eval("\x01") + 24);
  696.                                        loop7:
  697.                                        while(true)
  698.                                        {
  699.                                           set(┬º┬ºpop(),eval("\x01") + 98);
  700.                                           if(┬º┬ºpop())
  701.                                           {
  702.                                              set("\x01",eval("\x01") - 830);
  703.                                           }
  704.                                           while(true)
  705.                                           {
  706.                                              if(eval("\x01") == 876)
  707.                                              {
  708.                                                 set("\x01",eval("\x01") - 697);
  709.                                                 ┬º┬ºpush(true);
  710.                                                 continue;
  711.                                              }
  712.                                              if(eval("\x01") == 22)
  713.                                              {
  714.                                                 set("\x01",eval("\x01") + 246);
  715.                                                 if(┬º┬ºpop())
  716.                                                 {
  717.                                                    set("\x01",eval("\x01") + 330);
  718.                                                 }
  719.                                                 continue;
  720.                                              }
  721.                                              if(eval("\x01") == 150)
  722.                                              {
  723.                                                 set("\x01",eval("\x01") + 80);
  724.                                                 ┬º┬ºpush(true);
  725.                                                 continue;
  726.                                              }
  727.                                              if(eval("\x01") == 980)
  728.                                              {
  729.                                                 break loop7;
  730.                                              }
  731.                                              if(eval("\x01") == 598)
  732.                                              {
  733.                                                 set("\x01",eval("\x01") - 261);
  734.                                                 ┬º┬ºpush(true);
  735.                                                 continue;
  736.                                              }
  737.                                              if(eval("\x01") == 230)
  738.                                              {
  739.                                                 set("\x01",eval("\x01") - 156);
  740.                                                 if(┬º┬ºpop())
  741.                                                 {
  742.                                                    set("\x01",eval("\x01") + 233);
  743.                                                 }
  744.                                                 continue;
  745.                                              }
  746.                                              if(eval("\x01") == 775)
  747.                                              {
  748.                                                 set("\x01",eval("\x01") - 753);
  749.                                                 ┬º┬ºpush(true);
  750.                                                 continue;
  751.                                              }
  752.                                              if(eval("\x01") == 294)
  753.                                              {
  754.                                                 set("\x01",eval("\x01") + 588);
  755.                                                 ┬º┬ºpush(true);
  756.                                                 continue;
  757.                                              }
  758.                                              if(eval("\x01") == 268)
  759.                                              {
  760.                                                 set("\x01",eval("\x01") + 330);
  761.                                              }
  762.                                              if(eval("\x01") == 882)
  763.                                              {
  764.                                                 break;
  765.                                              }
  766.                                              if(eval("\x01") == 337)
  767.                                              {
  768.                                                 set("\x01",eval("\x01") + 304);
  769.                                                 if(┬º┬ºpop())
  770.                                                 {
  771.                                                    set("\x01",eval("\x01") - 347);
  772.                                                 }
  773.                                                 continue;
  774.                                              }
  775.                                              if(eval("\x01") == 179)
  776.                                              {
  777.                                                 set("\x01",eval("\x01") + 20);
  778.                                                 if(┬º┬ºpop())
  779.                                                 {
  780.                                                    set("\x01",eval("\x01") + 576);
  781.                                                 }
  782.                                                 continue;
  783.                                              }
  784.                                              if(eval("\x01") == 776)
  785.                                              {
  786.                                                 set("\x01",eval("\x01") + 201);
  787.                                                 if(_root["aso#58267"]["aso#59659"] > 2)
  788.                                                 {
  789.                                                    return undefined;
  790.                                                 }
  791.                                                 if(_root["aso#58267"]["aso#59659"] == -1)
  792.                                                 {
  793.                                                    return undefined;
  794.                                                 }
  795.                                                 if(eval("aso#92388").text == "START")
  796.                                                 {
  797.                                                    _root["aso#58267"]["aso#01161"]();
  798.                                                 }
  799.                                                 else if(eval("aso#92388").text == "PAUSE")
  800.                                                 {
  801.                                                    _root["aso#58267"]["aso#06437"]();
  802.                                                 }
  803.                                                 else if(eval("aso#92388").text == "RESUME")
  804.                                                 {
  805.                                                    _root["aso#58267"]["aso#87078"]();
  806.                                                 }
  807.                                                 _root["aso#58267"]["aso#84586"]();
  808.                                              }
  809.                                              else
  810.                                              {
  811.                                                 if(eval("\x01") == 641)
  812.                                                 {
  813.                                                    set("\x01",eval("\x01") - 347);
  814.                                                 }
  815.                                                 if(eval("\x01") == 74)
  816.                                                 {
  817.                                                    set("\x01",eval("\x01") + 233);
  818.                                                 }
  819.                                                 if(eval("\x01") == 307)
  820.                                                 {
  821.                                                    set("\x01",eval("\x01") + 469);
  822.                                                    continue;
  823.                                                 }
  824.                                                 if(eval("\x01") == 199)
  825.                                                 {
  826.                                                    set("\x01",eval("\x01") + 576);
  827.                                                 }
  828.                                                 if(eval("\x01") == 977)
  829.                                                 {
  830.                                                    set("\x01",eval("\x01") - 977);
  831.                                                 }
  832.                                              }
  833.                                           }
  834.                                        }
  835.                                        set("\x01",eval("\x01") - 830);
  836.                                     }
  837.                                     else
  838.                                     {
  839.                                        if(eval("\x01") == 542)
  840.                                        {
  841.                                           set("\x01",eval("\x01") - 403);
  842.                                           ┬º┬ºpush(true);
  843.                                           continue;
  844.                                        }
  845.                                        if(eval("\x01") == 101)
  846.                                        {
  847.                                           set("\x01",eval("\x01") + 480);
  848.                                           if(┬º┬ºpop())
  849.                                           {
  850.                                              set("\x01",eval("\x01") + 259);
  851.                                           }
  852.                                           continue;
  853.                                        }
  854.                                        if(eval("\x01") == 717)
  855.                                        {
  856.                                           set("\x01",eval("\x01") - 359);
  857.                                           stop();
  858.                                        }
  859.                                        else
  860.                                        {
  861.                                           if(eval("\x01") == 139)
  862.                                           {
  863.                                              set("\x01",eval("\x01") + 485);
  864.                                              if(┬º┬ºpop())
  865.                                              {
  866.                                                 set("\x01",eval("\x01") + 24);
  867.                                              }
  868.                                              continue;
  869.                                           }
  870.                                           if(eval("\x01") == 358)
  871.                                           {
  872.                                              set("\x01",eval("\x01") - 358);
  873.                                           }
  874.                                        }
  875.                                     }
  876.                                  }
  877.                               }
  878.                            }
  879.                         }
  880.                         set("\x01",eval("\x01") + 103);
  881.                      }
  882.                      else if(eval("\x01") == 151)
  883.                      {
  884.                         set("\x01",eval("\x01") + 400);
  885.                         stop();
  886.                      }
  887.                      else if(eval("\x01") == 505)
  888.                      {
  889.                         set("\x01",eval("\x01") + 349);
  890.                      }
  891.                      else if(eval("\x01") == 551)
  892.                      {
  893.                         set("\x01",eval("\x01") - 551);
  894.                      }
  895.                      else
  896.                      {
  897.                         if(eval("\x01") == 913)
  898.                         {
  899.                            set("\x01",eval("\x01") - 798);
  900.                            ┬º┬ºpush(true);
  901.                            continue;
  902.                         }
  903.                         if(eval("\x01") == 635)
  904.                         {
  905.                            set("\x01",eval("\x01") + 278);
  906.                            stop();
  907.                            ┬º┬ºpush(new ┬º┬ºpop()[┬º┬ºpop()]());
  908.                         }
  909.                         else
  910.                         {
  911.                            if(eval("\x01") == 828)
  912.                            {
  913.                               set("\x01",eval("\x01") - 439);
  914.                               if(┬º┬ºpop())
  915.                               {
  916.                                  set("\x01",eval("\x01") + 350);
  917.                               }
  918.                               continue;
  919.                            }
  920.                            if(eval("\x01") == 200)
  921.                            {
  922.                               set("\x01",eval("\x01") + 435);
  923.                               if(┬º┬ºpop())
  924.                               {
  925.                                  set("\x01",eval("\x01") + 278);
  926.                               }
  927.                               continue;
  928.                            }
  929.                            if(eval("\x01") == 765)
  930.                            {
  931.                               set("\x01",eval("\x01") - 653);
  932.                               if(┬º┬ºpop())
  933.                               {
  934.                                  set("\x01",eval("\x01") + 263);
  935.                               }
  936.                               continue;
  937.                            }
  938.                            if(eval("\x01") == 634)
  939.                            {
  940.                               set("\x01",eval("\x01") + 100);
  941.                            }
  942.                            else
  943.                            {
  944.                               if(eval("\x01") == 265)
  945.                               {
  946.                                  set("\x01",eval("\x01") - 43);
  947.                                  if(┬º┬ºpop())
  948.                                  {
  949.                                     set("\x01",eval("\x01") + 261);
  950.                                  }
  951.                                  continue;
  952.                               }
  953.                               if(eval("\x01") == 341)
  954.                               {
  955.                                  set("\x01",eval("\x01") + 293);
  956.                                  if(┬º┬ºpop())
  957.                                  {
  958.                                     set("\x01",eval("\x01") + 100);
  959.                                  }
  960.                                  continue;
  961.                               }
  962.                            }
  963.                         }
  964.                      }
  965.                   }
  966.                }
  967.             }
  968.          }
  969.       }
  970.       set("\x01",eval("\x01") + 263);
  971.       if(┬º┬ºpop())
  972.       {
  973.       }
  974.    }
  975.    else
  976.    {
  977.       while(true)
  978.       {
  979.          set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  980.          loop1:
  981.          while(true)
  982.          {
  983.             while(true)
  984.             {
  985.                if(eval("\x01") == 189)
  986.                {
  987.                   set("\x01",eval("\x01") + 398);
  988.                   ┬º┬ºpush(true);
  989.                   continue;
  990.                }
  991.                if(eval("\x01") == 831)
  992.                {
  993.                   set("\x01",eval("\x01") - 485);
  994.                   if(┬º┬ºpop())
  995.                   {
  996.                      set("\x01",eval("\x01") + 243);
  997.                   }
  998.                   continue;
  999.                }
  1000.                if(eval("\x01") == 324)
  1001.                {
  1002.                   set("\x01",eval("\x01") + 161);
  1003.                   if(┬º┬ºpop())
  1004.                   {
  1005.                      break loop1;
  1006.                   }
  1007.                   continue loop1;
  1008.                }
  1009.                if(eval("\x01") == 587)
  1010.                {
  1011.                   set("\x01",eval("\x01") - 448);
  1012.                   if(┬º┬ºpop())
  1013.                   {
  1014.                      set("\x01",eval("\x01") + 458);
  1015.                   }
  1016.                   continue;
  1017.                }
  1018.                if(eval("\x01") == 589)
  1019.                {
  1020.                   set("\x01",eval("\x01") + 358);
  1021.                   ┬º┬ºpush(true);
  1022.                   continue;
  1023.                }
  1024.                if(eval("\x01") == 139)
  1025.                {
  1026.                   set("\x01",eval("\x01") + 458);
  1027.                   break;
  1028.                }
  1029.                if(eval("\x01") == 94)
  1030.                {
  1031.                   set("\x01",eval("\x01") + 230);
  1032.                   ┬º┬ºpush(true);
  1033.                   continue;
  1034.                }
  1035.                if(eval("\x01") != 663)
  1036.                {
  1037.                   if(eval("\x01") == 609)
  1038.                   {
  1039.                      set("\x01",eval("\x01") + 54);
  1040.                      if(┬º┬ºpop())
  1041.                      {
  1042.                         set("\x01",eval("\x01") - 350);
  1043.                      }
  1044.                   }
  1045.                   else if(eval("\x01") == 947)
  1046.                   {
  1047.                      set("\x01",eval("\x01") - 231);
  1048.                      if(┬º┬ºpop())
  1049.                      {
  1050.                         set("\x01",eval("\x01") - 647);
  1051.                      }
  1052.                   }
  1053.                   else
  1054.                   {
  1055.                      if(eval("\x01") == 485)
  1056.                      {
  1057.                         set("\x01",eval("\x01") - 363);
  1058.                         getURL(┬º┬ºpop(),┬º┬ºpop());
  1059.                         break;
  1060.                      }
  1061.                      if(eval("\x01") == 346)
  1062.                      {
  1063.                         set("\x01",eval("\x01") + 243);
  1064.                         break;
  1065.                      }
  1066.                      if(eval("\x01") == 39)
  1067.                      {
  1068.                         set("\x01",eval("\x01") + 613);
  1069.                         if(┬º┬ºpop())
  1070.                         {
  1071.                            set("\x01",eval("\x01") - 558);
  1072.                         }
  1073.                      }
  1074.                      else if(eval("\x01") == 600)
  1075.                      {
  1076.                         set("\x01",eval("\x01") - 193);
  1077.                         if(┬º┬ºpop())
  1078.                         {
  1079.                            set("\x01",eval("\x01") + 56);
  1080.                         }
  1081.                      }
  1082.                      else
  1083.                      {
  1084.                         if(eval("\x01") == 313)
  1085.                         {
  1086.                            set("\x01",eval("\x01") + 436);
  1087.                            stop();
  1088.                            break;
  1089.                         }
  1090.                         if(eval("\x01") == 122)
  1091.                         {
  1092.                            set("\x01",eval("\x01") + 478);
  1093.                            ┬º┬ºpush(true);
  1094.                         }
  1095.                         else
  1096.                         {
  1097.                            if(eval("\x01") == 652)
  1098.                            {
  1099.                               set("\x01",eval("\x01") - 558);
  1100.                               break;
  1101.                            }
  1102.                            if(eval("\x01") == 716)
  1103.                            {
  1104.                               set("\x01",eval("\x01") - 647);
  1105.                               ┬º┬ºpush(mblength(ord(mbsubstring(┬º┬ºpop(),┬º┬ºpop(),mbsubstring(┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop() eq ┬º┬ºpop())))));
  1106.                               break;
  1107.                            }
  1108.                            if(eval("\x01") == 407)
  1109.                            {
  1110.                               set("\x01",eval("\x01") + 56);
  1111.                               break;
  1112.                            }
  1113.                            if(eval("\x01") == 597)
  1114.                            {
  1115.                               set("\x01",eval("\x01") - 558);
  1116.                               ┬º┬ºpush(true);
  1117.                            }
  1118.                            else if(eval("\x01") == 463)
  1119.                            {
  1120.                               set("\x01",eval("\x01") + 368);
  1121.                               ┬º┬ºpush(true);
  1122.                            }
  1123.                            else
  1124.                            {
  1125.                               if(eval("\x01") != 69)
  1126.                               {
  1127.                                  if(eval("\x01") == 749)
  1128.                                  {
  1129.                                     set("\x01",eval("\x01") - 749);
  1130.                                     break;
  1131.                                  }
  1132.                                  break;
  1133.                               }
  1134.                               set("\x01",eval("\x01") + 540);
  1135.                               ┬º┬ºpush(true);
  1136.                            }
  1137.                         }
  1138.                      }
  1139.                   }
  1140.                   continue;
  1141.                }
  1142.                set("\x01",eval("\x01") - 350);
  1143.                throw ┬º┬ºpop();
  1144.             }
  1145.          }
  1146.       }
  1147.    }
  1148. }
  1149. catch(�c-Y��/e� |�,�q4�-͑����x�=)�$��r.�]k���N5�K���,���T� ;� )
  1150. {
  1151.    set("\x01",eval("\x01") - 295);
  1152. }
  1153. finally
  1154. {
  1155.    ┬º┬ºpop() add ┬º┬ºpop();
  1156. }
  1157. set(§§pop(),§§pop());
  1158. §§goto(addr3820);
  1159.